IRIX Base Documentation 2002 November/SGI IRIX Base Documentation 2002 November.iso/usr/share/catman/p_man/cat3/SCSL/ccfftf.z/ccfftf

Text File | 2002-10-03 | 17.2 KB | 331 lines

CCCCCCCCFFFFFFFFTTTTFFFF((((3333SSSS))))                                                          CCCCCCCCFFFFFFFFTTTTFFFF((((3333SSSS))))



NNNNAAAAMMMMEEEE
     CCCCCCCCFFFFFFFFTTTTFFFF, CCCCCCCCFFFFFFFFTTTTMMMMFFFF, CCCCCCCCFFFFFFFFTTTTMMMMRRRRFFFF, CCCCCCCCFFFFFFFFTTTT2222DDDDFFFF, CCCCCCCCFFFFFFFFTTTT3333DDDDFFFF, ZZZZZZZZFFFFFFFFTTTTFFFF, ZZZZZZZZFFFFFFFFTTTTMMMMFFFF, ZZZZZZZZFFFFFFFFTTTTMMMMRRRRFFFF,
     ZZZZZZZZFFFFFFFFTTTT2222DDDDFFFF, ZZZZZZZZFFFFFFFFTTTT3333DDDDFFFF - Deallocate memory tacked on to the table array
     during initialization

SSSSYYYYNNNNOOOOPPPPSSSSIIIISSSS
     Single precision complex -> Single precision complex

          Fortran:
               _i_s_t_a_t_u_s ==== CCCCCCCCFFFFFFFFTTTTFFFF ((((_n,,,, _t_a_b_l_e))))
               _i_s_t_a_t_u_s ==== CCCCCCCCFFFFFFFFTTTTMMMMFFFF ((((_n,,,, _t_a_b_l_e))))
               _i_s_t_a_t_u_s ==== CCCCCCCCFFFFFFFFTTTTMMMMRRRRFFFF ((((_n,,,, _t_a_b_l_e))))
               _i_s_t_a_t_u_s ==== CCCCCCCCFFFFFFFFTTTT2222DDDDFFFF ((((_n_1,,,, _n_2,,,, _t_a_b_l_e))))
               _i_s_t_a_t_u_s ==== CCCCCCCCFFFFFFFFTTTT3333DDDDFFFF ((((_n_1,,,, _n_2,,,, _n_3,,,, _t_a_b_l_e))))

          C/C++:
               ####iiiinnnncccclllluuuuddddeeee <<<<ssssccccssssllll____fffffffftttt....hhhh>>>>
               _i_s_t_a_t_u_s ==== ccccccccffffffffttttffff ((((iiiinnnntttt _n,,,, ffffllllooooaaaatttt *_t_a_b_l_e))));;;;
               _i_s_t_a_t_u_s ==== ccccccccffffffffttttmmmmffff ((((iiiinnnntttt _n,,,, ffffllllooooaaaatttt *_t_a_b_l_e))));;;;
               _i_s_t_a_t_u_s ==== ccccccccffffffffttttmmmmrrrrffff ((((iiiinnnntttt _n,,,, ffffllllooooaaaatttt *_t_a_b_l_e))));;;;
               _i_s_t_a_t_u_s ==== ccccccccfffffffftttt2222ddddffff ((((iiiinnnntttt _n_1,,,, iiiinnnntttt _n_2,,,, ffffllllooooaaaatttt *_t_a_b_l_e))));;;;
               _i_s_t_a_t_u_s ==== ccccccccfffffffftttt3333ddddffff ((((iiiinnnntttt _n_1,,,, iiiinnnntttt _n_2,,,, iiiinnnntttt _n_3,,,, ffffllllooooaaaatttt *_t_a_b_l_e))));;;;

     Double precision complex -> Double precision complex

          Fortran:
               _i_s_t_a_t_u_s ==== ZZZZZZZZFFFFFFFFTTTTFFFF ((((_n,,,, _t_a_b_l_e))))
               _i_s_t_a_t_u_s ==== ZZZZZZZZFFFFFFFFTTTTMMMMFFFF ((((_n,,,, _t_a_b_l_e))))
               _i_s_t_a_t_u_s ==== ZZZZZZZZFFFFFFFFTTTTMMMMRRRRFFFF ((((_n,,,, _t_a_b_l_e))))
               _i_s_t_a_t_u_s ==== ZZZZZZZZFFFFFFFFTTTT2222DDDDFFFF ((((_n_1,,,, _n_2,,,, _t_a_b_l_e))))
               _i_s_t_a_t_u_s ==== ZZZZZZZZFFFFFFFFTTTT3333DDDDFFFF ((((_n_1,,,, _n_2,,,, _n_3,,,, _t_a_b_l_e))))

          C/C++:
               ####iiiinnnncccclllluuuuddddeeee <<<<ssssccccssssllll____fffffffftttt....hhhh>>>>
               _i_s_t_a_t_u_s ==== zzzzzzzzffffffffttttffff ((((iiiinnnntttt _n,,,, ddddoooouuuubbbblllleeee *_t_a_b_l_e))));;;;
               _i_s_t_a_t_u_s ==== zzzzzzzzffffffffttttmmmmffff ((((iiiinnnntttt _n,,,, ddddoooouuuubbbblllleeee *_t_a_b_l_e))));;;;
               _i_s_t_a_t_u_s ==== zzzzzzzzffffffffttttmmmmrrrrffff ((((iiiinnnntttt _n,,,, ddddoooouuuubbbblllleeee *_t_a_b_l_e))));;;;
               _i_s_t_a_t_u_s ==== zzzzzzzzfffffffftttt2222ddddffff ((((iiiinnnntttt _n_1,,,, iiiinnnntttt _n_2,,,, ddddoooouuuubbbblllleeee *_t_a_b_l_e))));;;;
               _i_s_t_a_t_u_s ==== zzzzzzzzfffffffftttt3333ddddffff ((((iiiinnnntttt _n_1,,,, iiiinnnntttt _n_2,,,, iiiinnnntttt _n_3,,,, ddddoooouuuubbbblllleeee *_t_a_b_l_e))));;;;

IIIIMMMMPPPPLLLLEEEEMMMMEEEENNNNTTTTAAAATTTTIIIIOOOONNNN
     These routines are part of the SCSL Scientific Library and can be loaded
     using either the ----llllssssccccssss or the ----llllssssccccssss____mmmmpppp option.  The ----llllssssccccssss____mmmmpppp option
     directs the linker to use the multi-processor version of the library.

     When linking to SCSL with ----llllssssccccssss or ----llllssssccccssss____mmmmpppp, the default integer size is
     4 bytes (32 bits). Another version of SCSL is available in which integers
     are 8 bytes (64 bits).  This version allows the user access to larger
     memory sizes and helps when porting legacy Cray codes.  It can be loaded
     by using the ----llllssssccccssss____iiii8888 option or the ----llllssssccccssss____iiii8888____mmmmpppp option. A program may use
     only one of the two versions; 4-byte integer and 8-byte integer library
     calls cannot be mixed.



                                                                        PPPPaaaaggggeeee 1111






CCCCCCCCFFFFFFFFTTTTFFFF((((3333SSSS))))                                                          CCCCCCCCFFFFFFFFTTTTFFFF((((3333SSSS))))



     The C and C++ prototypes shown above are appropriate for the 4-byte
     integer version of SCSL. When using the 8-byte integer version, the
     variables of type iiiinnnntttt become lllloooonnnngggg lllloooonnnngggg and the <<<<ssssccccssssllll____fffffffftttt____iiii8888....hhhh>>>> header
     file should be included.

DDDDEEEESSSSCCCCRRRRIIIIPPPPTTTTIIIIOOOONNNN
     These routines deallocate memory added on to the _t_a_b_l_e array during
     initialization if the first element of the _i_s_y_s array was set to 0 in the
     call to CCCCCCCCFFFFFFFFTTTT(3S), CCCCCCCCFFFFFFFFTTTTMMMM(3S), CCCCCCCCFFFFFFFFTTTTMMMMRRRR((((3333SSSS)))), CCCCCCCCFFFFFFFFTTTT2222DDDD((((3333SSSS)))), CCCCCCCCFFFFFFFFTTTT3333DDDD((((3333SSSS)))),,,,
     ZZZZZZZZFFFFFFFFTTTT(3S), ZZZZZZZZFFFFFFFFTTTTMMMM(3S), ZZZZZZZZFFFFFFFFTTTTMMMMRRRR(3S), ZZZZZZZZFFFFFFFFTTTT2222DDDD(3S) or ZZZZZZZZFFFFFFFFTTTT3333DDDD(3S).  If the
     appropriate one of these deallocation routines is not used, that memory
     will leak, and repeated initializations using the same table array can
     exhaust memory.  If the first element of the _i_s_y_s array was set to 1 in
     the call to CCCCCCCCFFFFFFFFTTTT(3S), etc. (and this is the recommended value), there is
     no potential memory leak and these routines do not need to be called. If
     they are called, they will simply return 0.

     See the NOTES section of this man page for information about the
     interpretation of the data types described in the following arguments.

     These routines have the following arguments:

     _i_s_t_a_t_u_s   Integer (result status). (output)
               0 indicates the memory was successfully freed.  Non-zero
               indicates that the memory was not freed because the transform
               size did not match the supplied table array.

     _n         Integer.  (input)
               Size of the one dimensional transform (the number of values in
               the input array used to initialize table).  _n >= 0.

     _n_1        Integer.   (input)
               Transform size in the first dimension.

     _n_2        Integer.   (input)
               Transform size in the second dimension.

     _n_3        Integer.   (input)
               Transform size in the third dimension.

     _t_a_b_l_e     Array of the following dimensions. (input)
               CCCCCCCCFFFFFFFFTTTTFFFF: Single precision array of dimension (2*_n + _N_F).
               ZZZZZZZZFFFFFFFFTTTTFFFF: Double precision array of dimension (2*_n + _N_F).
               CCCCCCCCFFFFFFFFTTTTMMMMFFFF: Single precision array of dimension (2*_n + _N_F).
               ZZZZZZZZFFFFFFFFTTTTMMMMFFFF: Double precision array of dimension (2*_n + _N_F).
               CCCCCCCCFFFFFFFFTTTTMMMMRRRRFFFF: Single precision array of dimension (2*_n + _N_F).
               ZZZZZZZZFFFFFFFFTTTTMMMMRRRRFFFF: Double precision array of dimension (2*_n + _N_F).
               CCCCCCCCFFFFFFFFTTTT2222DDDDFFFF: Single precision array of dimension (2*_n_1 + _N_F) +
               (2*_n_2 + _N_F).
               ZZZZZZZZFFFFFFFFTTTT2222DDDDFFFF: Double precision array of dimension (2*_n_1 + _N_F) +
               (2*_n_2 + _N_F).
               CCCCCCCCFFFFFFFFTTTT3333DDDDFFFF: Single precision array of dimension (2*_n_1 + _N_F) +



                                                                        PPPPaaaaggggeeee 2222






CCCCCCCCFFFFFFFFTTTTFFFF((((3333SSSS))))                                                          CCCCCCCCFFFFFFFFTTTTFFFF((((3333SSSS))))



               (2*_n_2 + _N_F) + (2*_n_3 + _N_F).
               ZZZZZZZZFFFFFFFFTTTT3333DDDDFFFF: Double precision array of dimension (2*_n_1 + _N_F) +
               (2*_n_2 + _N_F) + (2*_n_3 + _N_F).
               Table of factors and roots of unity initialized by a call to
               the corresponding routine (CCCCCCCCFFFFFFFFTTTT, CCCCCCCCFFFFFFFFTTTTMMMM, CCCCCCCCFFFFFFFFTTTTMMMMRRRR, CCCCCCCCFFFFFFFFTTTT2222DDDD,
               CCCCCCCCFFFFFFFFTTTT3333DDDD, ZZZZZZZZFFFFFFFFTTTT, ZZZZZZZZFFFFFFFFTTTTMMMM, ZZZZZZZZFFFFFFFFTTTTMMMMRRRR, ZZZZZZZZFFFFFFFFTTTT2222DDDD, ZZZZZZZZFFFFFFFFTTTT3333DDDD).  _N_F = 30 if
               table was initialized using _i_s_y_s((((0000))))=0.  _N_F=256 if _t_a_b_l_e was
               initialized using _i_s_y_s((((0000))))=1.

NNNNOOOOTTTTEEEESSSS
     The following data types are described in this documentation:

          TTTTeeeerrrrmmmm UUUUsssseeeedddd                     DDDDaaaattttaaaa ttttyyyyppppeeee

     Fortran:

          Array dimensioned 0000........_n----1111      XXXX((((0000::::nnnn----1111))))

          Array of dimensions (_m,_n)     XXXX((((mmmm,,,,nnnn))))

          Array of dimensions (_m,_n,_p)   XXXX((((mmmm,,,,nnnn,,,,pppp))))

          Integer                       IIIINNNNTTTTEEEEGGGGEEEERRRR (IIIINNNNTTTTEEEEGGGGEEEERRRR****8888 for ----llllssssccccssss____iiii8888[[[[____mmmmpppp]]]])

          Single precision              RRRREEEEAAAALLLL

          Double precision              DDDDOOOOUUUUBBBBLLLLEEEE PPPPRRRREEEECCCCIIIISSSSIIIIOOOONNNN

          Single precision complex      CCCCOOOOMMMMPPPPLLLLEEEEXXXX

          Double precision complex      DDDDOOOOUUUUBBBBLLLLEEEE CCCCOOOOMMMMPPPPLLLLEEEEXXXX

     C/C++:

          Array dimensioned 0000........_n----1111      xxxx[[[[_n]]]]

          Array of dimensions (_m,_n)     xxxx[[[[mmmm****nnnn]]]] oooorrrr xxxx[[[[nnnn]]]][[[[mmmm]]]]

          Array of dimensions (_m,_n,_p)   xxxx[[[[mmmm****nnnn****pppp]]]] oooorrrr xxxx[[[[pppp]]]][[[[nnnn]]]][[[[mmmm]]]]

          Integer                       iiiinnnntttt (lllloooonnnngggg lllloooonnnngggg for ----llllssssccccssss____iiii8888[[[[____mmmmpppp]]]])

          Single precision              ffffllllooooaaaatttt

          Double precision              ddddoooouuuubbbblllleeee

          Single precision complex      ssssccccssssllll____ccccoooommmmpppplllleeeexxxx

          Double precision complex      ssssccccssssllll____zzzzoooommmmpppplllleeeexxxx






                                                                        PPPPaaaaggggeeee 3333






CCCCCCCCFFFFFFFFTTTTFFFF((((3333SSSS))))                                                          CCCCCCCCFFFFFFFFTTTTFFFF((((3333SSSS))))



EEEEXXXXAAAAMMMMPPPPLLLLEEEESSSS
     Initialize the complex array table in preparation for doing an FFT of
     size 1024. Take the FFT of _x and store the results in _y. Deallocate extra
     memory tagged on to the table array.

          Fortran:

               !    This example uses isys(0) = 0. The recommended value
               !    for current versions of SCSL is isys(0) = 1 which,
               !    if used, will eliminate the need to call CCFFTF.
               !
               COMPLEX X(0:1023), Y(0:1023)
               REAL TABLE(2*1024 + 30)  ! +30 too small for isys(0) = 1
               REAL WORK(2*1024)
               INTEGER ISYS(0:0)
               INTEGER ISTATUS, CCFFTF
               ISYS(0) = 0
               CALL CCFFT(0, 1024, 0.0, DUMMY, DUMMY, TABLE, DUMMY, 0)
               CALL CCFFT(1, 1024, 1.0, X, Y, TABLE, WORK, 0)
               ISTATUS = CCFFTF(1024, TABLE)


          C/C++:

          /* This example uses isys[0] = 0. The recommended value
           * for current versions of SCSL is isys[0] = 1 which,
           * if used, will eliminate the need to call ccfftf().
           */
          #include <scsl_fft.h>
          scsl_complex x[1024], y[1024];
          float table[2*1024 + 30];  /* +30 too small for isys[0] = 1*/
          float work[2*1024];
          int isys[1];
          int istatus;
          isys[0] = 0;
          ccfft(0, 1024, 0.0f, NULL, NULL, table, NULL, isys);
          ccfft(1, 1024, 1.0f, X, Y, table, work, isys);
          istatus = ccfftf(1024, table);


          C++ STL:

               // This example uses isys[0] = 0. The recommended value
               // for current versions of SCSL is isys[0] = 1 which,
               // if used, will eliminate the need to call ccfftf().
               //
               #include <complex.h>
               #include <scsl_fft.h>
               complex<float> x[1024], y[1024];
               float table[2*1024 + 30];  // +30 too small for isys[0] = 1
               float work[2*1024];
               int isys[1];



                                                                        PPPPaaaaggggeeee 4444






CCCCCCCCFFFFFFFFTTTTFFFF((((3333SSSS))))                                                          CCCCCCCCFFFFFFFFTTTTFFFF((((3333SSSS))))



               int istatus;
               isys[0] = 0;
               ccfft(0, 1024, 0.0f, NULL, NULL, table, NULL, isys);
               ccfft(1, 1024, 1.0f, X, Y, table, work, isys);
               istatus = ccfftf(1024, table);


SSSSEEEEEEEE AAAALLLLSSSSOOOO
     IIIINNNNTTTTRRRROOOO____FFFFFFFFTTTT(3S), IIIINNNNTTTTRRRROOOO____SSSSCCCCSSSSLLLL(3S)











































                                                                        PPPPaaaaggggeeee 5555